【LeetCode 393】UTF-8 Validation UTF-8 编码验证

发表于 | 分类于

[LeetCode 393]UTF-8 Validation UTF-8 编码验证

Problem description:

A character in UTF8 can be from 1 to 4 bytes long, subjected to the following rules:

  • For 1-byte character, the first bit is a 0, followed by its unicode code.
  • For n-bytes character, the first n-bits are all one’s, the n+1 bit is 0, followed by n-1 bytes with most significant 2 bits being 10.
    This is how the UTF-8 encoding would work: 
1
2
3
4
5
6
7
Char. number range  |        UTF-8 octet sequence
      (hexadecimal)    |              (binary)
   --------------------+---------------------------------------------
   0000 0000-0000 007F | 0xxxxxxx
   0000 0080-0000 07FF | 110xxxxx 10xxxxxx
   0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
   0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

Given an array of integers representing the data, return whether it is a valid utf-8 encoding.

Note:
The input is an array of integers. Only the least significant 8 bits of each integer is used to store the data. This means each integer represents only 1 byte of data.

Example1:

1
2
3
4
data = [197, 130, 1], which represents the octet sequence: 11000101 10000010 00000001.

Return true.
It is a valid utf-8 encoding for a 2-bytes character followed by a 1-byte character.

Example2:

1
2
3
4
5
6
data = [235, 140, 4], which represented the octet sequence: 11101011 10001100 00000100.

Return false.
The first 3 bits are all one's and the 4th bit is 0 means it is a 3-bytes character.
The next byte is a continuation byte which starts with 10 and that's correct.
But the second continuation byte does not start with 10, so it is invalid.

问题描述:

UTF-8 中的一个字符可能的长度为 1 到 4 字节，遵循以下的规则：

  • 对于 1 字节的字符，字节的第一位设为0，后面7位为这个符号的unicode码。
  • 对于 n 字节的字符 (n > 1)，第一个字节的前 n 位都设为1，第 n+1 位设为0，后面字节的前两位一律设为10。剩下的没有提及的二进制位，全部为这个符号的unicode码。

这是 UTF-8 编码的工作方式：

1
2
3
4
5
6
7
Char. number range  |        UTF-8 octet sequence
     (hexadecimal)    |              (binary)
  --------------------+---------------------------------------------
  0000 0000-0000 007F | 0xxxxxxx
  0000 0080-0000 07FF | 110xxxxx 10xxxxxx
  0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
  0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

给定一个表示数据的整数数组，返回它是否为有效的 utf-8 编码。

说明：
输入是整数数组。只有每个整数的最低 8 个有效位用来存储数据。这意味着每个整数只表示 1 字节的数据。

示例1:

1
2
3
4
data = [197, 130, 1], 表示 8 位的序列: 11000101 10000010 00000001.

返回 true 。
这是有效的 utf-8 编码，为一个2字节字符，跟着一个1字节字符。

示例2:

1
2
3
4
5
6
data = [235, 140, 4], 表示 8 位的序列: 11101011 10001100 00000100.

返回 false 。
前 3 位都是 1 ，第 4 位为 0 表示它是一个3字节字符。
下一个字节是开头为 10 的延续字节，这是正确的。
但第二个延续字节不以 10 开头，所以是不符合规则的。

Solution:

一开始我理解出现错误认为只有一个utf-8编码让你判断，其实是判断一组连续的编码序列，也就是若干个utf-8序列。

不用位运算的方法，也就是将每个数据通过Integer.toBinaryString(data).toCharArray来判断。

更简洁的做法是直接通过位运算来记录1的位数，过程如下:

  1. data>>5==0b110 右移5位如果是0b110说明有2个字节，还有1个字节需要额外判断
    （ 或者data & 0b11000000==0b11000000,与上述功能一致 ）
  2. data>>4==0b1110 右移4位如果是0b1110说明有3个字节，还有2个字节需要额外判断
  3. data>>3==0b11110 右移3位如果是0b110说明有4个字节，还有3个字节需要额外判断
  4. data>>7=0b1表示字符为10000000情况直接返回false
  5. 如果bitSize==1，表示当前为utf—8编码的第一个字符，做以上判断
  6. 如果bitSize!=1，表示当前正在判断10开头的字符，如果data[i]>>6!=0b10，直接返回false

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution {
    public boolean validUtf8(int[] data) {
        int bitSize=1;
        for(int i=0;i<data.length;i++){
            if(bitSize==1){
                if(data[i]>>5==0b110) bitSize=2;
                else if(data[i]>>4==0b1110) bitSize=3;
                else if(data[i]>>3==0b11110) bitSize=4;
                else if(data[i]>>7==0b1) return false;//10000000情况
            }else{
                if(data[i]>>6!=0b10) return false;

                bitSize--;

            }

        }
        return bitSize==1;

    }
}
Thanks!